home *** CD-ROM | disk | FTP | other *** search
/ The Arcade BBS / arcadebbs.zip / arcadebbs / bbstools / WWIV Mods / COMMON20.ZIP / COMMON.C next >
Encoding:
C/C++ Source or Header  |  1994-04-24  |  57.8 KB  |  2,843 lines
  1. // ************************************************************************* //
  2. // Begin COMMON mod, functions that are common amoung many Asylum releases   //
  3. // If you get a duplicate function error, then you have it installed twice   //
  4. // remove your oldest duplicated functions.                                  //
  5. // ************************************************************************* //
  6.  
  7. #include "vars.h"
  8. #include <stdarg.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <errno.h>
  13. #include <ctype.h>
  14. #include <conio.h>
  15.  
  16. // Makes the side menu to look fancy, show the hot char in a diffrent color
  17. // and will make sure the cursor is in a nice place, may be a little slower
  18. // for 2400 users
  19. #define FANCY_LIST
  20.  
  21.  
  22. int numlock=NOTNUMBERS;
  23.  
  24. unsigned char pd_getkey(void)
  25. {
  26.   unsigned char ch;
  27.   int beepyet;
  28.   long dd,tv,tv1;
  29.  
  30.   tleft(1);
  31.   
  32.   beepyet = 0;
  33.   timelastchar1=timer1();
  34.  
  35.   if (so())
  36.     tv=10920L;
  37.   else
  38.     tv=3276L;
  39.  
  40.   tv1=tv/2;
  41.  
  42.   lines_listed = 0;
  43.   do
  44.   {
  45.     while (empty() && !hangup)
  46.     {
  47.       dd = timer1();
  48.       if ((dd<timelastchar1) && ((dd+1000)>timelastchar1))
  49.         timelastchar1=dd;
  50.       if (labs(dd - timelastchar1) > 65536L)
  51.         timelastchar1 -= 1572480L;
  52.       if (((dd - timelastchar1) > tv1) && (!beepyet))
  53.       {
  54.         beepyet = 1;
  55.         outchr(7);
  56.       }
  57.       if (labs(dd - timelastchar1) > tv)
  58.       {
  59.         nl();
  60.         outstr("2Log off due to inactivity...Call back later when you are there.");
  61.         nl();
  62.         hangup = 1;
  63.       }
  64.       checkhangup();
  65.     }
  66.     ch = pd_inkey();
  67.   } while (!ch && !in_extern && !hangup);
  68.   if (checkit && (ch > 127)) {
  69.     checkit = 0;
  70.     ch = ch & (andwith = 0x7F);
  71.   }
  72.   return(ch);
  73. }
  74.  
  75.  
  76. char pd_inkey(void)
  77. {
  78.   char ch=0;
  79.   
  80.   tleft(1);
  81.  
  82.   if (x_only)
  83.     return(0);
  84.  
  85.   if (charbufferpointer) {
  86.     if (!charbuffer[charbufferpointer])
  87.       charbufferpointer = charbuffer[0] = 0;
  88.     else
  89.       return(charbuffer[charbufferpointer++]);
  90.   }
  91.   if (kbhitb() || (in_extern == 2)) {
  92.     ch = getchd1();
  93.     lastcon = 1;
  94.     if (!ch) {
  95.       if (in_extern)
  96.         in_extern = 2;
  97.       else {
  98.         ch = getchd1();
  99.         skey(ch);
  100.         ch = (((ch == 68) || (ch==103)) ? 2 : 0);
  101.       }
  102.     } else if (in_extern)
  103.       in_extern = 1;
  104.     timelastchar1=timer1();
  105.   } else if (incom && comhit()) {
  106.     ch = (get1c() & andwith);
  107.     lastcon = 0;
  108.   }
  109.   return(ch);
  110. }
  111.  
  112. unsigned side_menu(int *menu_pos, int redraw, char *menu_items[], int xpos, int ypos, struct side_menu_colors *smc)
  113. {
  114.   static int positions[20], amount=1;
  115.   int x;
  116.   unsigned event;
  117.  
  118.   tleft(1);
  119.   
  120.   if(redraw)
  121.   {
  122.     amount=1;
  123.     positions[0]=xpos;
  124.     while(menu_items[amount] && menu_items[amount][0] && !hangup )
  125.     {
  126.       positions[amount]=positions[amount-1]+strlen(menu_items[amount-1])+2;
  127.       ++amount;
  128.     }
  129.     
  130.     x=0;
  131.     setc(smc->normal_menu_item);
  132.  
  133.     while(menu_items[x] && menu_items[x][0] && !hangup)
  134.     {
  135.       GOTO_XY(positions[x], ypos);
  136.       
  137.       if(*menu_pos==x)
  138.       {
  139. #ifdef FANCY_LIST
  140.         setc(smc->current_highlight);
  141.         outchr(menu_items[x][0]);
  142.         setc(smc->current_menu_item);
  143.         outstr(menu_items[x]+1);
  144. #else        
  145.         setc(smc->current_menu_item);
  146.         outstr(menu_items[x]);
  147.         setc(smc->nomal_menu_item); // This #else only resets colors because fancy will take care of it self... just leave me here...
  148. #endif
  149.       }
  150.       else
  151. #ifdef FANCY_LIST        
  152.       {
  153.         setc(smc->normal_highlight);
  154.         outchr(menu_items[x][0]);
  155.         setc(smc->normal_menu_item);
  156.         outstr(menu_items[x]+1);
  157.       }
  158. #else      
  159.         outstr(menu_items[x]);
  160. #endif        
  161.         
  162.       ++x;
  163.     }
  164.   }
  165.   
  166.   
  167.   
  168.   setc(smc->normal_menu_item);
  169.  
  170.   while(!hangup)
  171.   {
  172.     event=get_kb_event();
  173.  
  174.        /* help       special command    help         extended key */
  175.     if(event==CO || event == SPACE || event == '?' || event==EXECUTE || event==GET_OUT || event == HELP || event == HOTKEY)
  176.       return event;
  177.     
  178.       
  179.     if(event<128)
  180.     {
  181.       int x=0;
  182.       while(menu_items[x] && menu_items[x][0] && !hangup)
  183.       {
  184.         if(event==toupper(menu_items[x][0]) || event==tolower(menu_items[x][0]))
  185.         {
  186.           GOTO_XY(positions[*menu_pos], ypos);
  187.           outstr(menu_items[*menu_pos]);
  188.           
  189.           *menu_pos=x;
  190.           setc(smc->current_menu_item);
  191.           GOTO_XY(positions[*menu_pos], ypos);
  192.           outstr(menu_items[*menu_pos]);
  193.           setc(smc->normal_menu_item);
  194.           
  195.           return(EXECUTE);
  196.         }
  197.         ++x;
  198.       }
  199.     }
  200.     else
  201.     {
  202.       switch(event)
  203.       {
  204.         case COMMAND_LEFT:
  205.           GOTO_XY(positions[*menu_pos], ypos);
  206. #ifdef FANCY_LIST        
  207.             setc(smc->normal_highlight);
  208.             outchr(menu_items[*menu_pos][0]);
  209.             setc(smc->normal_menu_item);
  210.             outstr(menu_items[*menu_pos]+1);
  211. #else      
  212.           outstr(menu_items[*menu_pos]);
  213. #endif          
  214.           if(!*menu_pos)
  215.             *menu_pos=amount-1;
  216.           else
  217.             --*menu_pos;
  218.             
  219. #ifdef FANCY_LIST        
  220.             setc(smc->current_highlight);
  221.             GOTO_XY(positions[*menu_pos], ypos);
  222.             outchr(menu_items[*menu_pos][0]);
  223.             setc(smc->current_menu_item);
  224.             outstr(menu_items[*menu_pos]+1);
  225. #else      
  226.           setc(smc->current_menu_item);
  227.           GOTO_XY(positions[*menu_pos], ypos);
  228.           outstr(menu_items[*menu_pos]);
  229.           setc(smc->normal_menu_item);
  230. #endif                    
  231.           
  232. #ifndef FANCY_LIST          
  233.           // Don't waist time putting the cursor in a nice pos at slow speeds
  234.           if(modem_speed>2400 || !using_modem)
  235. #endif            
  236.             GOTO_XY(positions[*menu_pos], ypos);
  237.  
  238.           
  239.           break;
  240.           
  241.         case COMMAND_RIGHT:
  242.           GOTO_XY(positions[*menu_pos], ypos);
  243. #ifdef FANCY_LIST        
  244.             setc(smc->normal_highlight);
  245.             outchr(menu_items[*menu_pos][0]);
  246.             setc(smc->normal_menu_item);
  247.             outstr(menu_items[*menu_pos]+1);
  248. #else      
  249.           outstr(menu_items[*menu_pos]);
  250. #endif          
  251.           if(*menu_pos==amount-1)
  252.             *menu_pos=0;
  253.           else
  254.             ++*menu_pos;
  255.             
  256. #ifdef FANCY_LIST        
  257.             setc(smc->current_highlight);
  258.             GOTO_XY(positions[*menu_pos], ypos);
  259.             outchr(menu_items[*menu_pos][0]);
  260.             setc(smc->current_menu_item);
  261.             outstr(menu_items[*menu_pos]+1);
  262. #else      
  263.           setc(smc->current_menu_item);
  264.           GOTO_XY(positions[*menu_pos], ypos);
  265.           outstr(menu_items[*menu_pos]);
  266.           setc(smc->normal_menu_item);
  267. #endif          
  268.             
  269. #ifndef FANCY_LIST          
  270.           // Don't waist time putting the cursor in a nice pos at slow speeds
  271.           if(modem_speed>2400 || !using_modem)
  272. #endif            
  273.             GOTO_XY(positions[*menu_pos], ypos);
  274.  
  275.           
  276.           break;
  277.           
  278.         default:
  279.           return(event);
  280.           
  281.       }
  282.     }
  283.   } // While !hangup   
  284.   return(0);      
  285. }          
  286.  
  287. // Set up a new control break handler so that my getch's wont break out of the bbs
  288. int new_control_break(void)
  289. {
  290.   sysoplog("Control Break pressed.  Program NOT aborting");
  291.   return 1;
  292. }
  293.  
  294. unsigned get_kb_event(void)
  295. {
  296.   time_t time1, time2;
  297.   unsigned key;
  298.  
  299.   ctrlbrk(new_control_break); // Disable control break
  300.   
  301.   tleft(1);
  302.   time(&time1);
  303.   
  304.  
  305.   
  306.   do{
  307.     time(&time2);
  308.     if(difftime(time2,time1) > 180 ) // greater than 3 minutes
  309.     {
  310.       hangup=1;
  311.       return 0;
  312.     }
  313.     if(hangup)
  314.       return 0;
  315.  
  316.     if(comhit() || kbhit())
  317.     {
  318.       if(!incom || kbhit())   // Check for local keys
  319.       {
  320.         key=getch();
  321.  
  322.         if(key==13 || key==12)
  323.         {
  324.           return(EXECUTE);
  325.         }
  326.         
  327.  
  328.         if(!key)
  329.         {
  330.           if(kbhit())
  331.           {
  332.             key=getch();
  333.             return(key<<4);
  334.           }
  335.         }
  336.         else 
  337.         {
  338.           if(numlock==NOTNUMBERS)
  339.           {
  340.             switch(key)
  341.             {
  342.               case '8':
  343.                 return(COMMAND_UP);
  344.               case '4':
  345.                 return(COMMAND_LEFT);
  346.               case '2':
  347.                 return(COMMAND_DOWN);
  348.               case '6':
  349.                 return(COMMAND_RIGHT);
  350.               case '0':
  351.                 return(COMMAND_INSERT);
  352.               case '.':
  353.                 return(COMMAND_DELETE);
  354.               case '9':
  355.                 return(COMMAND_PAGEUP);
  356.               case '3':
  357.                 return(COMMAND_PAGEDN);
  358.               case '7':
  359.                 return(COMMAND_HOME);
  360.               case '1':
  361.                 return(COMMAND_END);
  362.             }
  363.           } 
  364.           switch(key)
  365.           {
  366.             case TAB:
  367.               return(TAB); 
  368.             case ESC:
  369.               return(GET_OUT);
  370.             default:
  371.             {
  372.               return(key);
  373.             }
  374.           }
  375.         }
  376.       }
  377.       else if(comhit())
  378.       {
  379.         key=pd_getkey();
  380.  
  381.         if(key==13 || key==12)
  382.         {
  383.           return(EXECUTE);
  384.         }
  385.         
  386.         else if(key==ESC)
  387.         {
  388.           time_t time1;
  389.           time_t time2;
  390.  
  391.           time(&time1);
  392.           time(&time2);
  393.  
  394.           do{
  395.             time(&time2);
  396.  
  397.             if(comhit())
  398.             {
  399.               key=pd_getkey();
  400.               if(key==OB||key==O)
  401.               {
  402.                 key=pd_getkey();
  403.  
  404.                 // Check for a second set of brackets
  405.                 if(key==OB||key==O)
  406.                   key=pd_getkey();
  407.  
  408.                switch(key)
  409.                {
  410.                  case A_UP:
  411.                    return(COMMAND_UP);
  412.                  case A_LEFT:
  413.                    return(COMMAND_LEFT);
  414.                  case A_DOWN:
  415.                    return(COMMAND_DOWN);
  416.                  case A_RIGHT:
  417.                    return(COMMAND_RIGHT);
  418.                  case A_INSERT:
  419.                   return(COMMAND_INSERT);
  420.                  case A_DELETE:
  421.                   return(COMMAND_DELETE);
  422.                  case A_HOME:
  423.                    return(COMMAND_HOME);
  424.                  case A_END:
  425.                    return(COMMAND_END);
  426.                   
  427.                  default:
  428.                   return(key);
  429.                }
  430.              }
  431.              else
  432.              {
  433.                return(GET_OUT);
  434.              }
  435.            }
  436.          }while(difftime(time2,time1) < 1 && !hangup);
  437.          if(difftime(time2,time1) >= 1)  // if no keys followed ESC
  438.          {
  439.            return(GET_OUT);
  440.          }
  441.         }
  442.         else 
  443.         {
  444.           if(numlock==NOTNUMBERS)
  445.           {
  446.             switch(key)
  447.             {
  448.               case '8':
  449.                 return(COMMAND_UP);
  450.               case '4':
  451.                 return(COMMAND_LEFT);
  452.               case '2':
  453.                 return(COMMAND_DOWN);
  454.               case '6':
  455.                 return(COMMAND_RIGHT);
  456.               case '0':
  457.                 return(COMMAND_INSERT);
  458.               case '.':
  459.                 return(COMMAND_DELETE);
  460.               case '9':
  461.                 return(COMMAND_PAGEUP);
  462.               case '3':
  463.                 return(COMMAND_PAGEDN);
  464.               case '7':
  465.                 return(COMMAND_HOME);
  466.               case '1':
  467.                 return(COMMAND_END);
  468.             }
  469.           }  
  470.           switch(key)
  471.           {
  472.             case TAB:
  473.               return(TAB);
  474.             default:
  475.               return(key);
  476.           }
  477.         }
  478.       }
  479.       time(&time1);  // reset timer
  480.     }
  481.     
  482.   }while(!hangup);
  483.   return 0; // must have hung up
  484. }
  485.  
  486.  
  487.  
  488. // Does a one key, but has a default, ie onekdefault("ABCD", 'D') 
  489. // will default to d with the press of a return
  490. char onekdefault(char *s, char defaultchar)
  491. {
  492.   char ch;
  493.  
  494.   while (!strchr(s, ch = upcase(getkey())) && !hangup && ch != '\n' && ch != '\r')
  495.     ;
  496.   if (hangup)
  497.     ch = s[0];
  498.   if (ch == '\n' || ch == '\r')
  499.     return (defaultchar);
  500.   outchr(ch);
  501.   nl();
  502.   return (ch);
  503. }
  504.  
  505. // Like onek but does not put cursor down a line
  506. // One key, no carriage return
  507. char onek_ncr(char *s)
  508. {
  509.   char ch;
  510.  
  511.   while (!strchr(s, ch = upcase(getkey())) && !hangup)
  512.     ;
  513.   if (hangup)
  514.     ch = s[0];
  515.   outchr(ch);
  516.   return (ch);
  517. }
  518.  
  519.  
  520.  
  521.  
  522.  
  523.  
  524.  
  525.  
  526. int do_sysop_command(unsigned command)
  527. {
  528.   unsigned x;
  529.   int needredraw=0;
  530.  
  531.   switch(command)
  532.   {
  533.     // Commands that cause screen to need to be redrawn go here
  534.     case COMMAND_F1:
  535.     case COMMAND_CF1:
  536.     case COMMAND_CF9:
  537.     case COMMAND_F10:
  538.       needredraw=1;
  539.       x=command>>4;
  540.       break;
  541.  
  542.     // Commands that don't change the screen around
  543.     case COMMAND_SF1:
  544.     case COMMAND_F2:
  545.     case COMMAND_SF2:
  546.     case COMMAND_CF2:
  547.     case COMMAND_F3:
  548.     case COMMAND_SF3:
  549.     case COMMAND_CF3:
  550.     case COMMAND_F4:
  551.     case COMMAND_SF4:
  552.     case COMMAND_CF4:
  553.     case COMMAND_F5:
  554.     case COMMAND_SF5:
  555.     case COMMAND_CF5:
  556.     case COMMAND_F6:
  557.     case COMMAND_SF6:
  558.     case COMMAND_CF6:
  559.     case COMMAND_F7:
  560.     case COMMAND_SF7:
  561.     case COMMAND_CF7:
  562.     case COMMAND_F8:
  563.     case COMMAND_SF8:
  564.     case COMMAND_CF8:
  565.     case COMMAND_F9:
  566.     case COMMAND_SF9:
  567.     case COMMAND_SF10:
  568.     case COMMAND_CF10:
  569.       needredraw=0;
  570.       x=command>>4;
  571.       break;
  572.       
  573.     default:
  574.       x=0;
  575.       break;
  576.   }
  577.       
  578.   if(x)
  579.   {
  580.     if(needredraw)
  581.       CLS();
  582.  
  583.     skey(x);
  584.  
  585.     if(needredraw)
  586.       CLS();
  587.   }
  588.   
  589.   return(needredraw);
  590. }
  591.  
  592.  
  593.  
  594.  
  595. // All the diffrent functions that output strings to the screen and com
  596. // buffer, all of these need to be modifed to get the following color in
  597. // These don't count functions like npr and prt, since they end up calling
  598. // outstr to do the string printing... wonder if Wayne thinks he needs any
  599. // more functions to print string... hmmm....
  600. // outstr  OutString (COM.C)
  601. // pla     Print Line with Abort (BBSUTL.C)
  602. // plal    Print Line with Abort and Limit how much can be printed hmm npr... (BBSUTL.C)
  603. // osan    OutString with Abort and Next (MSGBASE.C)
  604. // plan    Print Line with Abort and Next (MSGBASE.C)
  605.  
  606. // Oh, colors are...
  607. // |00 - |15 regular dos forground colors
  608. // |16 - |23 OR |b0- |b7 for regular dos background colors
  609. // There MUST be two numbers following the pipe, ie |01 NOT |1
  610. void colorize_text(char *buffer)
  611. {
  612.   int pos=0, fmt_pos=0;
  613.   int attrib, col;
  614.   char num[3];
  615.   char *formated;
  616.   char color[50];
  617.   unsigned long x;
  618.  
  619.  
  620.   x=strlen(buffer);
  621.   x=(x)+100;
  622.  
  623.   formated=(char *)malloca(x);
  624.   if(!formated)
  625.   {
  626.     sysoplog("No mem to color text");
  627.     return;
  628.   }
  629.   formated[0]=0;
  630.  
  631.  
  632.   while(buffer[fmt_pos] && pos < x)
  633.   {
  634.     if(buffer[fmt_pos]=='|')
  635.     {
  636.       if(isdigit(buffer[fmt_pos+1]) || buffer[fmt_pos+1]==' ')
  637.       {
  638.         if(isdigit(buffer[fmt_pos+2]) || (buffer[fmt_pos+2]==' ' && buffer[fmt_pos+1]!=' '))
  639.         {
  640.  
  641.           if(buffer[fmt_pos+1]!='b' || buffer[fmt_pos+1]=='B')
  642.           {
  643.             strncpy(num, buffer+fmt_pos+1, 2);
  644.             num[2]=0;
  645.             col=atoi(num);
  646.  
  647.             if(col<16)
  648.             {
  649.               attrib=col;
  650.               buildfor(attrib, color);
  651.             }
  652.             else // For background colors 16-23)
  653.             {
  654.               col-=16;
  655.               attrib=col;
  656.               buildback(attrib, color);
  657.             }
  658.  
  659.             fmt_pos+=3;
  660.             strcat(formated, color);
  661.             pos+=strlen(color);
  662.           }
  663.           else if(buffer[fmt_pos+1]=='b' || buffer[fmt_pos+1]=='B')
  664.           {
  665.             strncpy(num, buffer+fmt_pos+2, 1);
  666.             num[1]=0;
  667.  
  668.             col=(atoi(num));
  669.             attrib=col;
  670.             buildback(attrib, color);
  671.  
  672.             fmt_pos+=3;
  673.             strcat(formated, color);
  674.             pos+=strlen(color);
  675.           }
  676.           else
  677.           {
  678.             formated[pos]=buffer[fmt_pos];
  679.             formated[pos+1]=0;
  680.             ++pos;
  681.             ++fmt_pos;
  682.           }
  683.         }
  684.         else
  685.         {
  686.           formated[pos]=buffer[fmt_pos];
  687.           formated[pos+1]=0;
  688.           ++pos;
  689.           ++fmt_pos;
  690.         }
  691.       }
  692.       else
  693.       {
  694.         formated[pos]=buffer[fmt_pos];
  695.         formated[pos+1]=0;
  696.         ++pos;
  697.         ++fmt_pos;
  698.       }
  699.     }
  700.     else
  701.     {
  702.       formated[pos]=buffer[fmt_pos];
  703.       formated[pos+1]=0;
  704.       ++pos;
  705.       ++fmt_pos;
  706.     }
  707.   }
  708.   formated[pos]=0;
  709.   strcpy(buffer, formated);
  710.   free(formated);
  711. }
  712.  
  713. // Calls the above colorize_text to print out '|colors'
  714. // This call and npr_color are only meant for formats that when expanded
  715. // Will be less that 512 characters, this is fine for most cases, but not
  716. // Something like an extended description
  717. void sprintf_color(char *buffer, char *fmt, ...)
  718. {
  719.   va_list ap;
  720.  
  721.   va_start(ap, fmt);
  722.   vsprintf(buffer, fmt, ap);
  723.   va_end(ap);
  724.  
  725.   colorize_text(buffer);
  726. }
  727.  
  728.  
  729.  
  730. void show_common_mods(void)
  731. {
  732.   existprint("COMMON.LST");
  733. }
  734.  
  735.  
  736.  
  737.  
  738. int copyfile(char *src, char *dst, int stats)
  739. {
  740.   char source[201], dest[201];
  741.   char *cbuff;
  742.   int origfile, destfile;
  743.   int amount;
  744.  
  745.   char sys[201];
  746.  
  747.  
  748.   strcpy(source, src);
  749.   strcpy(dest, dst);
  750.  
  751.   strupr(source);
  752.   strupr(dest);
  753.  
  754.  
  755.   sprintf(sys, "8Copy File: 9%s 8- ", src);
  756.   sysoplog(sys);
  757.   pl(sys);
  758.  
  759.  
  760.   if(exist(dest))
  761.     return 1;
  762.  
  763.   origfile=sh_open1(source,O_RDONLY | O_BINARY);
  764.  
  765.   strcpy(sys, "Error on copy");
  766.   if(origfile==-1)
  767.   {
  768.     ansic(3);
  769.     pl(sys);
  770.     sysoplog(sys);
  771.  
  772.     return 0;
  773.   }
  774.   destfile=sh_open1(dest,O_RDWR | O_BINARY | O_CREAT | O_TRUNC);
  775.   if(destfile==-1)
  776.   {
  777.     ansic(3);
  778.     pl(sys);
  779.     sysoplog(sys);
  780.  
  781.     sh_close(origfile);
  782.     return 0;
  783.   }
  784.  
  785.   else  /* copy file */
  786.   {
  787.     if((cbuff=(char *)malloca(25000))==NULL)
  788.     {
  789.       sysoplog("Could not allocate memory to copy file");
  790.       sh_close(origfile);
  791.       sh_close(destfile);
  792.       return 0;
  793.     }
  794.     else  // If this does not get executed, it was a failure
  795.     {
  796.       long fl;
  797.       int bar, largflag=0, flag2=1;
  798.       int xx=0;
  799.  
  800.       fl=filelength(origfile);
  801.  
  802.       bar=(int)((fl/25000)+1);
  803.       if(bar>79)
  804.       {
  805.         bar/=2;
  806.         largflag=1;
  807.       }
  808.  
  809.  
  810.       if(stats)
  811.       {
  812.         ansic(2);
  813.         outchr('[');
  814.         ansic(5);
  815.  
  816.         while(xx<bar+largflag)
  817.         {
  818.           outchr('∙');
  819.           ++xx;
  820.         }
  821.  
  822.         ansic(2);
  823.         outchr(']');
  824.  
  825.         if(okansi())
  826.           CURSORLEFT(xx+2);
  827.         else
  828.           repeat_char('\b', xx+2); // Hope they don't have destructive backspace turned on
  829.  
  830.         ansic(2);
  831.         outchr('[');
  832.         ansic(5);
  833.       }
  834.  
  835.       amount=sh_read(origfile, (void *)cbuff, 25000);
  836.  
  837.       if(stats)
  838.         outchr('▒');
  839.  
  840.       while(amount>0)
  841.       {
  842.         sh_write(destfile,(void *)cbuff,amount);
  843.  
  844.  
  845.         if(stats)
  846.         {
  847.           if(largflag)
  848.           {
  849.             if(flag2)
  850.             {
  851.               flag2=0;
  852.             }
  853.             else
  854.             {
  855.               outchr('\b');
  856.               outchr('▓');
  857.               flag2=1;
  858.             }
  859.           }
  860.           else
  861.           {
  862.             outchr('\b');
  863.             outchr('▓');
  864.           }
  865.         }
  866.  
  867.         amount=sh_read(origfile,(void *)cbuff,25000);
  868.  
  869.  
  870.         if(stats)
  871.         {
  872.           if(amount)
  873.           {
  874.             if(largflag)
  875.             {
  876.               if(flag2)
  877.                 outchr('▒');
  878.             }
  879.             else
  880.               outchr('▒');
  881.           }
  882.         }
  883.       }
  884.  
  885.       sh_close(origfile);
  886.       sh_close(destfile);
  887.       farfree(cbuff);
  888.       nl();
  889.     }
  890.   }
  891.   return(2);
  892. }
  893.  
  894. int movefile(char *src, char *dst, int stats)
  895. {
  896.   char source[201], dest[201];
  897.   char *cbuff;
  898.   int origfile, destfile;
  899.   int amount;
  900.  
  901.   char sys[201];
  902.  
  903.  
  904.   strcpy(source, src);
  905.   strcpy(dest, dst);
  906.  
  907.   strupr(source);
  908.   strupr(dest);
  909.  
  910.  
  911.   sprintf(sys, "8Move File: 9%s 8- ", src);
  912.   sysoplog(sys);
  913.   pl(sys);
  914.  
  915.  
  916.   if ((strcmp(source,dest)!=0) && (exist(source)))
  917.   {
  918.     int which_way=0;
  919.     if ((source[1]!=':') && (dest[1]!=':'))
  920.       which_way=1;
  921.     if ((source[1]==':') && (dest[1]==':') && (source[0]==dest[0]))
  922.       which_way=1;
  923.  
  924.     if (which_way)
  925.     {
  926.       rename(source, dest);
  927.       return 2;
  928.     }
  929.   }
  930.  
  931.  
  932.   origfile=sh_open1(source,O_RDONLY | O_BINARY);
  933.  
  934.   strcpy(sys, "Error on move");
  935.   if(origfile==-1)
  936.   {
  937.     ansic(3);
  938.     pl(sys);
  939.     sysoplog(sys);
  940.  
  941.     return 0;
  942.   }
  943.   destfile=sh_open1(dest,O_RDWR | O_BINARY | O_CREAT | O_TRUNC);
  944.   if(destfile==-1)
  945.   {
  946.     ansic(3);
  947.     pl(sys);
  948.     sysoplog(sys);
  949.  
  950.     sh_close(origfile);
  951.     return 0;
  952.   }
  953.  
  954.   else  /* copy file */
  955.   {
  956.     if((cbuff=(char *)malloca(25000))==NULL)
  957.     {
  958.       sysoplog("Could not allocate memory to copy file");
  959.       sh_close(origfile);
  960.       sh_close(destfile);
  961.       return 0;
  962.     }
  963.     else  // If this does not get executed, it was a failure
  964.     {
  965.       long fl;
  966.       int bar, largflag=0, flag2=1;
  967.       int xx=0;
  968.  
  969.       fl=filelength(origfile);
  970.  
  971.       bar=(int)((fl/25000)+1);
  972.       if(bar>79)
  973.       {
  974.         bar/=2;
  975.         largflag=1;
  976.       }
  977.  
  978.  
  979.       if(stats)
  980.       {
  981.         ansic(2);
  982.         outchr(5);
  983.         ansic(5);
  984.  
  985.         while(xx<bar+largflag)
  986.         {
  987.           outchr('∙');
  988.           ++xx;
  989.         }
  990.  
  991.         ansic(2);
  992.         outchr(']');
  993.  
  994.         if(okansi())
  995.           CURSORLEFT(xx+2);
  996.         else
  997.           repeat_char('\b', xx+2); // Hope they don't have destructive backspace turned on
  998.  
  999.         ansic(2);
  1000.         outchr('[');
  1001.         ansic(5);
  1002.       }
  1003.  
  1004.       amount=sh_read(origfile, (void *)cbuff, 25000);
  1005.  
  1006.       if(stats)
  1007.         outchr('▒');
  1008.  
  1009.       while(amount>0)
  1010.       {
  1011.         sh_write(destfile,(void *)cbuff,amount);
  1012.  
  1013.  
  1014.         if(stats)
  1015.         {
  1016.           if(largflag)
  1017.           {
  1018.             if(flag2)
  1019.             {
  1020.               flag2=0;
  1021.             }
  1022.             else
  1023.             {
  1024.               outchr('\b');
  1025.               outchr('▓');
  1026.  
  1027.               flag2=1;
  1028.             }
  1029.           }
  1030.           else
  1031.           {
  1032.             outchr('\b');
  1033.             outchr('▓');
  1034.           }
  1035.         }
  1036.  
  1037.         amount=sh_read(origfile,(void *)cbuff,25000);
  1038.  
  1039.  
  1040.         if(stats)
  1041.         {
  1042.           if(amount)
  1043.           {
  1044.             if(largflag)
  1045.             {
  1046.               if(flag2)
  1047.                 outchr('▒');
  1048.             }
  1049.             else
  1050.               outchr('▒');
  1051.           }
  1052.         }
  1053.       }
  1054.  
  1055.       sh_close(origfile);
  1056.       sh_close(destfile);
  1057.       farfree(cbuff);
  1058.       nl();
  1059.     }
  1060.   }
  1061.   unlink(src);
  1062.  
  1063.   return 2;
  1064. }
  1065.  
  1066.  
  1067.  
  1068. char **alloc_2d(int row, int col, unsigned size)
  1069. {
  1070.    int i;
  1071.    char **prow, *pdata;
  1072.  
  1073.    pdata = (char *) calloc(row * col, size);
  1074.    if (pdata == (char *) NULL) {
  1075.       sysoplog("No heap space for data\n");
  1076.       pl("Memory Error!");
  1077.       hangup=1;
  1078.       return(NULL);
  1079.    }
  1080.    prow  = (char **) malloc(row * sizeof (char *));
  1081.    if (prow == (char **) NULL) {
  1082.       sysoplog("No heap space for row pointers\n");
  1083.       pl("Memory Error!");
  1084.       hangup=1;
  1085.       free(pdata);
  1086.       return(NULL);
  1087.    }
  1088.  
  1089.    for (i = 0; i < row; i++) {
  1090.      prow[i] = pdata;             /* store pointers to rows */
  1091.      pdata += size * col;         /* move to next row */
  1092.    }
  1093.    return prow;                   /* pointer to 2D array */
  1094. }
  1095.  
  1096. void free_2d(char **pa)
  1097. {
  1098.    free(*pa);                    /* free the data */
  1099.    free(pa);                     /* free pointer to row pointers */
  1100. }
  1101.  
  1102.  
  1103.  
  1104. varimenurec * addvarimenu(varimenurec *current, varimenurec *newitem)
  1105. {
  1106.   varimenurec *temp;
  1107.   int cur, amount;
  1108.  
  1109.   if(current==NULL)
  1110.   {
  1111.     current=(varimenurec *) malloc(sizeof(varimenurec));
  1112.     memmove((void *)current, (void *)newitem, sizeof(varimenurec));
  1113.  
  1114.     current->next=NULL;
  1115.     current->amount=1;
  1116.  
  1117.     return(current);
  1118.   }
  1119.  
  1120.  
  1121.   amount=current->amount;
  1122.   cur=0;
  1123.   temp=current;
  1124.  
  1125.   while(cur<amount-1)
  1126.   {
  1127.     temp=temp->next;
  1128.     ++cur;
  1129.   }
  1130.  
  1131.   temp->next=(varimenurec *) malloc(sizeof(varimenurec));
  1132.   temp=temp->next;
  1133.  
  1134.   memmove((void *)temp, (void *)newitem, sizeof(varimenurec));
  1135.   temp->next=NULL;
  1136.  
  1137.   ++current->amount;
  1138.   return(current);
  1139. }
  1140.  
  1141. void varimenuforward(varimenurec *menu, varimenuinfo *info)
  1142. {
  1143.   varimenurec *temp;
  1144.   int done=0, cur=0, amount=menu->amount;
  1145.  
  1146.   info->last=info->pos;
  1147.  
  1148.   while(!done)
  1149.   {
  1150.     if(info->pos)
  1151.     {
  1152.       --info->pos;
  1153.       temp=getvarimenurec(menu, info->pos);
  1154.       if(temp->active)
  1155.       {
  1156.         done=1;
  1157.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1158.       }
  1159.     }
  1160.     else
  1161.     {
  1162.       info->pos=amount-1;
  1163.  
  1164.       temp=getvarimenurec(menu, info->pos);
  1165.       if(temp->active)
  1166.       {
  1167.         done=1;
  1168.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1169.       }
  1170.     }
  1171.  
  1172.     ++cur;
  1173.  
  1174.     if(cur==amount)
  1175.       done=1;
  1176.   }
  1177. }
  1178.  
  1179. void varimenubackward(varimenurec *menu, varimenuinfo *info)
  1180. {
  1181.   varimenurec *temp;
  1182.   int done=0, cur=0, amount=menu->amount;
  1183.  
  1184.   info->last=info->pos;
  1185.  
  1186.   while(!done)
  1187.   {
  1188.     if(info->pos<amount-1)
  1189.     {
  1190.       ++info->pos;
  1191.  
  1192.       temp=getvarimenurec(menu, info->pos);
  1193.       if(temp->active)
  1194.       {
  1195.         done=1;
  1196.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1197.       }
  1198.     }
  1199.     else
  1200.     {
  1201.       info->pos=0;
  1202.  
  1203.       temp=getvarimenurec(menu, info->pos);
  1204.       if(temp->active)
  1205.       {
  1206.         done=1;
  1207.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1208.       }
  1209.     }
  1210.     ++cur;
  1211.  
  1212.     if(cur==amount)
  1213.       done=1;
  1214.   }
  1215. }
  1216.  
  1217. void varimenuleft(varimenurec *menu, varimenuinfo *info)
  1218. {
  1219.   varimenurec *temp;
  1220.   int done=0, cur=0, amount=menu->amount;
  1221.   int looky=0;
  1222.  
  1223.   info->last=info->pos;
  1224.  
  1225.   temp=getvarimenurec(menu, info->pos);
  1226.   looky=temp->ypos;
  1227.  
  1228.  
  1229.   while(!done)
  1230.   {
  1231.     int thisy=0;
  1232.  
  1233.     if(info->pos)
  1234.     {
  1235.       --info->pos;
  1236.       temp=getvarimenurec(menu, info->pos);
  1237.  
  1238.       thisy=temp->ypos;
  1239.  
  1240.       if(thisy==looky && temp->active)
  1241.       {
  1242.         done=1;
  1243.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1244.       }
  1245.     }
  1246.     else
  1247.     {
  1248.       if(looky)
  1249.         --looky;
  1250.       else
  1251.         looky=60;
  1252.  
  1253.       info->pos=amount-1;
  1254.  
  1255.       temp=getvarimenurec(menu, info->pos);
  1256.       thisy=temp->ypos;
  1257.  
  1258.       if(thisy==looky && temp->active)
  1259.       {
  1260.         done=1;
  1261.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1262.       }
  1263.     }
  1264.  
  1265.     ++cur;
  1266.  
  1267. //    if(cur==amount)
  1268. //      done=1;
  1269.   }
  1270.   
  1271. }
  1272.  
  1273. void varimenuup(varimenurec *menu, varimenuinfo *info)
  1274. {
  1275.   varimenurec *temp;
  1276.   int done=0, cur=0, amount=menu->amount;
  1277.   int lookx=0;
  1278.  
  1279.   info->last=info->pos;
  1280.  
  1281.   temp=getvarimenurec(menu, info->pos);
  1282.   lookx=temp->xpos;
  1283.  
  1284.  
  1285.   while(!done)
  1286.   {
  1287.     int thisx=0;
  1288.  
  1289.     if(info->pos)
  1290.     {
  1291.       --info->pos;
  1292.       temp=getvarimenurec(menu, info->pos);
  1293.       thisx=temp->xpos;
  1294.  
  1295.       if(thisx==lookx && temp->active)
  1296.       {
  1297.         done=1;
  1298.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1299.       }
  1300.     }
  1301.     else
  1302.     {
  1303.       if(lookx)
  1304.         --lookx;
  1305.       else
  1306.         lookx=80;
  1307.  
  1308.  
  1309.  
  1310.       info->pos=amount-1;
  1311.  
  1312.       temp=getvarimenurec(menu, info->pos);
  1313.       thisx=temp->xpos;
  1314.  
  1315.       if(thisx==lookx && temp->active)
  1316.       {
  1317.         done=1;
  1318.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1319.       }
  1320.     }
  1321.  
  1322.     ++cur;
  1323.  
  1324. //    if(cur==amount)
  1325. //      done=1;
  1326.   }
  1327.   
  1328. }
  1329.  
  1330. void varimenuright(varimenurec *menu, varimenuinfo *info)
  1331. {
  1332.   varimenurec *temp;
  1333.   int done=0, cur=0, amount=menu->amount;
  1334.   int looky;
  1335.  
  1336.   info->last=info->pos;
  1337.  
  1338.   temp=getvarimenurec(menu, info->pos);
  1339.   looky=temp->ypos;
  1340.  
  1341.  
  1342.   while(!done)
  1343.   {
  1344.     int thisy;
  1345.  
  1346.     if(info->pos<amount-1)
  1347.     {
  1348.       ++info->pos;
  1349.  
  1350.       temp=getvarimenurec(menu, info->pos);
  1351.       thisy=temp->ypos;
  1352.  
  1353.       if(thisy==looky && temp->active)
  1354.       {
  1355.         done=1;
  1356.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1357.       }
  1358.     }
  1359.     else
  1360.     {
  1361.       if(looky<=60)
  1362.         ++looky;
  1363.       else
  1364.         looky=0;
  1365.  
  1366.  
  1367.       info->pos=0;
  1368.  
  1369.       temp=getvarimenurec(menu, info->pos);
  1370.       thisy=temp->ypos;
  1371.  
  1372.       if(thisy==looky && temp->active)
  1373.       {
  1374.         done=1;
  1375.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1376.       }
  1377.     }
  1378.     ++cur;
  1379.  
  1380. //    if(cur==amount)
  1381. //      done=1;
  1382.   }
  1383. }
  1384.  
  1385. void varimenudown(varimenurec *menu, varimenuinfo *info)
  1386. {
  1387.   varimenurec *temp;
  1388.   int done=0, cur=0, amount=menu->amount;
  1389.   int lookx;
  1390.  
  1391.   info->last=info->pos;
  1392.  
  1393.   temp=getvarimenurec(menu, info->pos);
  1394.   lookx=temp->xpos;
  1395.  
  1396.  
  1397.   while(!done)
  1398.   {
  1399.     int thisx;
  1400.  
  1401.     if(info->pos<amount-1)
  1402.     {
  1403.       ++info->pos;
  1404.  
  1405.       temp=getvarimenurec(menu, info->pos);
  1406.       thisx=temp->xpos;
  1407.  
  1408.       if(thisx==lookx && temp->active)
  1409.       {
  1410.         done=1;
  1411.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1412.       }
  1413.     }
  1414.     else
  1415.     {
  1416.       if(lookx<120)
  1417.         ++lookx;
  1418.       else
  1419.         lookx=0;
  1420.  
  1421.  
  1422.  
  1423.       info->pos=0;
  1424.  
  1425.       temp=getvarimenurec(menu, info->pos);
  1426.       thisx=temp->xpos;
  1427.  
  1428.       if(thisx==lookx && temp->active)
  1429.       {
  1430.         done=1;
  1431.         redrawvarimenu(COMMON_PARTIAL, menu, info);
  1432.       }
  1433.     }
  1434.     ++cur;
  1435.  
  1436. //    if(cur==amount)
  1437. //      done=1;
  1438.   }
  1439. }
  1440.  
  1441.  
  1442. void varimenu(varimenurec *menu, varimenuinfo *info)
  1443. {
  1444.   varimenurec *temp;
  1445.  
  1446.  
  1447.   if(info->redraw!=COMMON_NONE)
  1448.     redrawvarimenu(info->redraw, menu, info);
  1449.  
  1450.   info->redraw=COMMON_NONE;
  1451.  
  1452.   while(1)
  1453.   {
  1454.     temp=getvarimenurec(menu, info->pos);
  1455.     switch(temp->type)
  1456.     {
  1457.       case SHOW_TEXT_TYPE:
  1458.         showtext(&temp->types->st, info);
  1459.         break;
  1460.  
  1461.       case INPUT_EDIT_TYPE:
  1462.         input_edit(&temp->types->ie, info);
  1463.         break;
  1464.  
  1465.       case RADIO_BUTTON_TYPE:
  1466.         radio_button(&temp->types->rb, info);
  1467.         break;
  1468.  
  1469.       case CHECK_BOX_TYPE:
  1470.         check_box(&temp->types->cb, info);
  1471.         break;
  1472.  
  1473.  
  1474.       default:
  1475.         sysoplog("Undefined type in varimenu");
  1476.         break;
  1477.     }
  1478.  
  1479.     if(varimenu_findhotkey(menu, info) > -1000)
  1480.     {
  1481.       redrawvarimenu(COMMON_PARTIAL, menu, info);
  1482.  
  1483.       temp=getvarimenurec(menu, info->pos);
  1484.       info->returnvalue=temp->returnvalue;
  1485.  
  1486.       return;
  1487.     }
  1488.  
  1489.     switch(info->event)
  1490.     {
  1491.       case COMMAND_STAB:
  1492.         varimenuforward(menu, info);
  1493.         break;
  1494.  
  1495.       case COMMAND_UP:
  1496.         varimenuup(menu, info);
  1497.         break;
  1498.  
  1499.       case COMMAND_LEFT:
  1500.         varimenuleft(menu, info);
  1501.         break;
  1502.  
  1503.       case COMMAND_DOWN:
  1504.         varimenudown(menu, info);
  1505.         break;
  1506.  
  1507.       case COMMAND_RIGHT:
  1508.         varimenuright(menu, info);
  1509.         break;
  1510.  
  1511.       case TAB:
  1512.         varimenubackward(menu, info);
  1513.         break;
  1514.  
  1515.       default:
  1516.  
  1517.         temp=getvarimenurec(menu, info->pos);
  1518.         info->returnvalue=temp->returnvalue;
  1519.         return;
  1520.     }
  1521.   }
  1522. }
  1523.  
  1524. varimenurec * getvarimenurec(varimenurec *menu, int which)
  1525. {
  1526.   varimenurec *temp;
  1527.   int pos=0;
  1528.   int amount=menu->amount;
  1529.  
  1530.   if(which>=amount)
  1531.   {
  1532.     sysoplog("Tried to get a varimenuitem that is out of range");
  1533.     return NULL;
  1534.   }
  1535.  
  1536.   temp=menu;
  1537.   if(which==0)
  1538.     return(temp);
  1539.  
  1540.  
  1541.  
  1542.   while(pos<which)
  1543.   {
  1544.     temp=temp->next;
  1545.     if(pos==which)
  1546.       return(temp);
  1547.  
  1548.     ++pos;
  1549.   }
  1550.  
  1551.   return(temp);
  1552. }
  1553.  
  1554.  
  1555.  
  1556.  
  1557. void redrawvarimenu(int redraw, varimenurec *menu, varimenuinfo *info)
  1558. {
  1559.   varimenurec *temp;
  1560.   int cur, savecolor=curatr;
  1561.   int mode;
  1562.  
  1563.  
  1564.  
  1565.   if(redraw==COMMON_FULL)
  1566.   {
  1567.     cur=0;
  1568.     temp=menu;
  1569.  
  1570.     setc(info->mi_normal);
  1571.  
  1572.  
  1573.     while(cur<menu->amount)
  1574.     {
  1575.       if(cur)
  1576.         temp=temp->next;
  1577.       else
  1578.         temp=menu;
  1579.  
  1580.       mode = temp->active==FALSE ? COMMON_INACTIVE : cur==info->pos ? COMMON_CURRENT : COMMON_ITEM;
  1581.  
  1582.  
  1583.       switch(temp->type)
  1584.       {
  1585.         case SHOW_TEXT_TYPE:
  1586.           redrawshowtext(COMMON_FULL, &temp->types->st, info, mode);
  1587.           break;
  1588.  
  1589.         case INPUT_EDIT_TYPE:
  1590.           redrawinputedit(COMMON_FULL, &temp->types->ie, info, mode);
  1591.           break;
  1592.  
  1593.         case RADIO_BUTTON_TYPE:
  1594.           redrawradiobutton(COMMON_FULL, &temp->types->rb, info, mode);
  1595.           break;
  1596.  
  1597.         case CHECK_BOX_TYPE:
  1598.           redrawcheckbox(COMMON_FULL, &temp->types->cb, info, mode);
  1599.           break;
  1600.  
  1601.         default:
  1602.           sysoplog("Undefined type in redrawvarimenu");
  1603.           break;
  1604.       }
  1605.  
  1606.       ++cur;
  1607.     }
  1608.   }
  1609.   else if(redraw==COMMON_PARTIAL)
  1610.   {
  1611.     if(info->pos!=info->last)
  1612.     {
  1613.       temp=getvarimenurec(menu, info->pos);
  1614.  
  1615.       mode = temp->active==FALSE ? COMMON_INACTIVE : COMMON_CURRENT;
  1616.  
  1617.       switch(temp->type)
  1618.       {
  1619.         case SHOW_TEXT_TYPE:
  1620.           redrawshowtext(COMMON_NONE, &temp->types->st, info, mode);
  1621.           break;
  1622.  
  1623.         case INPUT_EDIT_TYPE:
  1624.           redrawinputedit(COMMON_NONE, &temp->types->ie, info, mode);
  1625.           break;
  1626.  
  1627.         case RADIO_BUTTON_TYPE:
  1628.           redrawradiobutton(COMMON_NONE, &temp->types->rb, info, mode);
  1629.           break;
  1630.  
  1631.         case CHECK_BOX_TYPE:
  1632.           redrawcheckbox(COMMON_NONE, &temp->types->cb, info, mode);
  1633.           break;
  1634.  
  1635.  
  1636.         default:
  1637.           sysoplog("Undefined type in redrawvarimenu");
  1638.           break;
  1639.       }
  1640.  
  1641.  
  1642.  
  1643.       temp=getvarimenurec(menu, info->last);
  1644.  
  1645.       mode = temp->active==FALSE ? COMMON_INACTIVE : COMMON_ITEM;
  1646.  
  1647.       switch(temp->type)
  1648.       {
  1649.         case SHOW_TEXT_TYPE:
  1650.           redrawshowtext(COMMON_FULL, &temp->types->st, info, mode);
  1651.           break;
  1652.  
  1653.         case INPUT_EDIT_TYPE:
  1654.           redrawinputedit(COMMON_FULL, &temp->types->ie, info, mode);
  1655.           break;
  1656.  
  1657.         case RADIO_BUTTON_TYPE:
  1658.           redrawradiobutton(COMMON_FULL, &temp->types->rb, info, mode);
  1659.           break;
  1660.  
  1661.         case CHECK_BOX_TYPE:
  1662.           redrawcheckbox(COMMON_FULL, &temp->types->cb, info, mode);
  1663.           break;
  1664.  
  1665.  
  1666.         default:
  1667.           sysoplog("Undefined type in redrawvarimenu");
  1668.           break;
  1669.       }
  1670.     }
  1671.  
  1672.   }
  1673.   else if(redraw==COMMON_NONE)
  1674.   {
  1675.     return;
  1676.   }
  1677.   else
  1678.   {
  1679.     sysoplog("RedrawVariMenu is getting an invalid redraw value");
  1680.     return;
  1681.   }
  1682.  
  1683.   GOTO_XY(info->xpos, info->ypos);
  1684.   setc(savecolor);
  1685. }
  1686.  
  1687.  
  1688. void killvarimenu(varimenurec *menu)
  1689. {
  1690.   varimenurec *m[100];
  1691.   int cur=1, amount=menu->amount;
  1692.  
  1693.   m[0]=menu;
  1694.  
  1695.   while(cur < amount)
  1696.   {
  1697.     m[cur]=m[cur-1]->next;
  1698.     ++cur;
  1699.   }
  1700.  
  1701.   cur=0;
  1702.   while(cur < amount)
  1703.   {
  1704.     if(m[cur]->type==INPUT_EDIT_TYPE)
  1705.       kill_inputrec(&m[cur]->types->ie);
  1706.     else if(m[cur]->type==SHOW_TEXT_TYPE)
  1707.       kill_showtextrec(&m[cur]->types->st);
  1708.     else if(m[cur]->type==RADIO_BUTTON_TYPE)
  1709.       kill_radiobutton(&m[cur]->types->rb);
  1710.     else if(m[cur]->type==CHECK_BOX_TYPE)
  1711.       kill_checkbox(&m[cur]->types->cb);
  1712.  
  1713.  
  1714.  
  1715.     free(m[cur]);
  1716.     ++cur;
  1717.   }
  1718. }
  1719.  
  1720. void kill_inputrec(inputeditrec *input)
  1721. {
  1722.   free(input->text);
  1723.   free(input->show);
  1724. }
  1725.  
  1726. void kill_showtextrec(showtextrec *text)
  1727. {
  1728.   free(text->text);
  1729.   free(text->show);
  1730. }
  1731.  
  1732. void kill_radiobutton(radiobuttonrec *radio)
  1733. {
  1734.   if(radio!=radio)
  1735.     radio=radio;
  1736. }
  1737.  
  1738. void kill_checkbox(checkboxrec *check)
  1739. {
  1740.   if(check!=check)
  1741.     check=check;
  1742. }
  1743.  
  1744.  
  1745.  
  1746.  
  1747.  
  1748.  
  1749. int varimenu_findhotkey(varimenurec *menu, varimenuinfo *info)
  1750. {
  1751.   varimenurec *m;
  1752.   int cur=0, amount=menu->amount;
  1753.  
  1754.   unsigned e, h;
  1755.  
  1756.  
  1757.   m=menu;
  1758.  
  1759.   e=info->event;
  1760.   h=m->hotkey;
  1761.  
  1762.   if(!h || !e)
  1763.     return -1001;
  1764.  
  1765.   if(e>='A' && e <='Z')
  1766.     e=tolower(e);
  1767.   if(h>='A' && h <='Z')
  1768.     h=tolower(h);
  1769.  
  1770.   if(e==h && e)
  1771.   {
  1772.     if(menu->type==SHOW_TEXT_TYPE)
  1773.       info->event=EXECUTE;
  1774.     info->last=info->pos;
  1775.     info->pos=cur;
  1776.  
  1777.     return 1;
  1778.   }
  1779.  
  1780.   ++cur;  // we checked pos 0, inc up to pos 1
  1781.   while(cur < amount)
  1782.   {
  1783.     m=m->next;
  1784.  
  1785.     h=m->hotkey;
  1786.     if(h>='A' && h <='Z')
  1787.       h=tolower(h);
  1788.  
  1789.  
  1790.     if(e==h && e)
  1791.     {
  1792.       if(menu->type==SHOW_TEXT_TYPE)
  1793.         info->event=EXECUTE;
  1794.       info->last=info->pos;
  1795.       info->pos=cur;
  1796.  
  1797.       return 1;
  1798.     }
  1799.  
  1800.     ++cur;
  1801.  
  1802.   }
  1803.   return -1001;
  1804. }
  1805.  
  1806.  
  1807. void fillvarimenurec(varimenurec *menu, void *rec, int type, unsigned hotkey, int returnvalue, int active)
  1808. {
  1809.   memset(menu, 0, sizeof(varimenurec));
  1810.  
  1811.   (void *)menu->types=rec;
  1812.  
  1813.   menu->type=type;
  1814.  
  1815.   menu->hotkey=hotkey;
  1816.   menu->returnvalue=returnvalue;
  1817.  
  1818.   menu->active=active;
  1819.  
  1820.   switch(menu->type)
  1821.   {
  1822.     case SHOW_TEXT_TYPE:
  1823.       menu->xpos=menu->types->st.xpos;
  1824.       menu->ypos=menu->types->st.ypos;
  1825.       break;
  1826.  
  1827.     case INPUT_EDIT_TYPE:
  1828.       menu->xpos=menu->types->ie.xpos;
  1829.       menu->ypos=menu->types->ie.ypos;
  1830.       break;
  1831.  
  1832.     case RADIO_BUTTON_TYPE:
  1833.       menu->xpos=menu->types->rb.xpos;
  1834.       menu->ypos=menu->types->rb.ypos;
  1835.       break;
  1836.  
  1837.     case CHECK_BOX_TYPE:
  1838.       menu->xpos=menu->types->cb.xpos;
  1839.       menu->ypos=menu->types->cb.ypos;
  1840.       break;
  1841.   }
  1842. }
  1843.  
  1844.  
  1845.  
  1846. void build_inputrec(inputeditrec *input, int maxlen, int xpos, int ypos, int width, int insert, int char_case)
  1847. {
  1848.   memset(input, 0, sizeof(inputeditrec));
  1849.  
  1850.   input->pos=0;
  1851.   input->curlen=0;
  1852.   input->maxlen=maxlen;
  1853.   input->first=0;
  1854.   input->xpos=xpos;
  1855.   input->ypos=ypos;
  1856.   input->amount_to_show=width;
  1857.   input->curxpos=xpos;
  1858.   input->curypos=ypos;
  1859.   input->insert=insert;
  1860.   input->curmode=-1;
  1861.   input->text=(char *)malloc(maxlen+1);
  1862.   memset(input->text, 0, maxlen+1);
  1863.   input->show=(char *)malloc(width+5);
  1864.   memset(input->show, 0, width);
  1865.   input->char_case=char_case;
  1866. }
  1867.  
  1868. void build_radiobuttonrec(radiobuttonrec *radio, int xpos, int ypos, int amount, int pos, int rc, int fc)
  1869. {
  1870.   memset(radio, 0, sizeof(radiobuttonrec));
  1871.   radio->xpos=xpos;
  1872.   radio->ypos=ypos;
  1873.   radio->amount=amount;
  1874.   radio->pos=pos;
  1875.  
  1876.   if(pos >= amount)
  1877.     pos=amount-1;
  1878.  
  1879.   radio->radio_char=rc;
  1880.   radio->fill_char=fc;
  1881. }
  1882.  
  1883. void build_checkboxrec(checkboxrec *check, int xpos, int ypos, int amount, int pos, unsigned bi, int rc, int fc)
  1884. {
  1885.   memset(check, 0, sizeof(checkboxrec));
  1886.   check->xpos=xpos;
  1887.   check->ypos=ypos;
  1888.   check->amount=amount;
  1889.   check->bi.n.ni=bi;
  1890.  
  1891.   check->pos=pos;
  1892.   if(pos >= amount)
  1893.     pos=amount-1;
  1894.  
  1895.  
  1896.   check->check_char=rc;
  1897.   check->fill_char=fc;
  1898. }
  1899.  
  1900. void radio_button(radiobuttonrec *radio, varimenuinfo *info)
  1901. {
  1902.   if(info->redraw!=COMMON_NONE)
  1903.     redrawradiobutton(info->redraw, radio, info, COMMON_CURRENT);
  1904.  
  1905.   while(1)
  1906.   {
  1907.     info->event=get_kb_event();
  1908.  
  1909.     switch(info->event)
  1910.     {
  1911.       case COMMAND_UP:
  1912.         radio->last=radio->pos;
  1913.         if(radio->pos)
  1914.         {
  1915.           --radio->pos;
  1916.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1917.         }
  1918.         else
  1919.         {
  1920.           radio->pos=radio->amount-1;
  1921.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1922.         }
  1923.         info->event=0;
  1924.         return;
  1925.         
  1926.       case COMMAND_DOWN:
  1927.         radio->last=radio->pos;
  1928.         if(radio->pos<radio->amount-1)
  1929.         {
  1930.           ++radio->pos;
  1931.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1932.         }
  1933.         else
  1934.         {
  1935.           radio->pos=0;
  1936.           redrawradiobutton(COMMON_PARTIAL, radio, info, COMMON_CURRENT);
  1937.         }
  1938.         info->event=0;
  1939.         return;
  1940.  
  1941.       default:
  1942.         return;
  1943.     }
  1944.   }
  1945. }
  1946.  
  1947. void check_box(checkboxrec *check, varimenuinfo *info)
  1948. {
  1949.   if(info->redraw!=COMMON_NONE)
  1950.     redrawcheckbox(info->redraw, check, info, COMMON_CURRENT);
  1951.  
  1952.   while(1)
  1953.   {
  1954.     info->event=get_kb_event();
  1955.  
  1956.     switch(info->event)
  1957.     {
  1958.       case COMMAND_UP:
  1959.         if(check->pos)
  1960.         {
  1961.           --check->pos;
  1962.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1963.         }
  1964.         else
  1965.         {
  1966.           check->pos=check->amount-1;
  1967.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1968.         }
  1969.         info->event=0;
  1970.         return;
  1971.         
  1972.       case COMMAND_DOWN:
  1973.         if(check->pos<check->amount-1)
  1974.         {
  1975.           ++check->pos;
  1976.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1977.         }
  1978.         else
  1979.         {
  1980.           check->pos=0;
  1981.           redrawcheckbox(COMMON_NONE, check, info, COMMON_CURRENT);
  1982.         }
  1983.         info->event=0;
  1984.         return;
  1985.  
  1986.       case ' ':
  1987.         if(BitTst(check->bi.n.ni, check->pos))
  1988.           check->bi.n.ni=BitClr(check->bi.n.ni, check->pos);
  1989.         else
  1990.           check->bi.n.ni=BitSet(check->bi.n.ni, check->pos);
  1991.  
  1992.         redrawcheckbox(COMMON_PARTIAL, check, info, COMMON_CURRENT);
  1993.         info->event=0;
  1994.         return;
  1995.  
  1996.       default:
  1997.         return;
  1998.  
  1999.     }
  2000.   }
  2001. }
  2002.  
  2003.  
  2004.  
  2005. void input_edit(inputeditrec *input, varimenuinfo *info)
  2006. {
  2007.   if(info->redraw!=COMMON_NONE)
  2008.     redrawinputedit(info->redraw, input, info, COMMON_CURRENT);
  2009.  
  2010.   while(1)
  2011.   {
  2012.     info->event=get_kb_event();
  2013.     input->bs=FALSE;
  2014.  
  2015.     switch(info->event)
  2016.     {
  2017.       case COMMAND_LEFT:
  2018.         if(input->pos)
  2019.         {
  2020.           --input->pos;
  2021.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2022.         }
  2023.         info->event=0;
  2024.         return;
  2025.         
  2026.       case COMMAND_RIGHT:
  2027.         if(input->pos<input->curlen)
  2028.         {
  2029.           ++input->pos;
  2030.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2031.         }
  2032.         info->event=0;
  2033.         return;
  2034.  
  2035.       case COMMAND_HOME:
  2036.         if(input->pos!=0)
  2037.         {
  2038.           input->pos=0;
  2039.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2040.         }
  2041.         info->event=0;
  2042.         return;
  2043.  
  2044.       case COMMAND_END:
  2045.         if(input->pos!=input->maxlen)
  2046.         {
  2047.           input->pos=input->curlen;
  2048.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2049.         }
  2050.         info->event=0;
  2051.         return;
  2052.  
  2053.       case COMMAND_INSERT:
  2054.         input->insert=!input->insert;
  2055.         info->event=0;
  2056.         return;
  2057.  
  2058.       case BACKSPACE:
  2059.         if(input->pos)
  2060.         {
  2061.           --input->pos;
  2062.           delete_inputedit(input, info);
  2063.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2064.         }
  2065.         info->event=0;
  2066.         return;
  2067.  
  2068.       case COMMAND_DELETE:
  2069.         delete_inputedit(input, info);
  2070.         redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2071.         info->event=0;
  2072.         return;
  2073.  
  2074.       case COMMAND_STAB:
  2075.       case TAB:
  2076.         return;
  2077.  
  2078.       default:
  2079.  
  2080.         if(ok_char_inputedit(input, info))
  2081.         {
  2082.           if(input->char_case==IE_UPPER)
  2083.             info->event=toupper(info->event);
  2084.           else if(input->char_case==IE_PROPPER)
  2085.           {
  2086.             if(input->pos && isspace(input->text[input->pos-1]))
  2087.               info->event=toupper(info->event);
  2088.           }
  2089.  
  2090.           add_char_inputedit(input, info);
  2091.           redrawinputedit(COMMON_PARTIAL, input, info, COMMON_CURRENT);
  2092.  
  2093.           info->event=0;
  2094.           return;
  2095.         }
  2096.         else
  2097.           return;
  2098.     }
  2099.   }
  2100. }
  2101.  
  2102. int ok_char_inputedit(inputeditrec *input, varimenuinfo *info)
  2103. {
  2104.   unsigned event;
  2105.  
  2106.   event=info->event;
  2107.  
  2108.   if(event >= ' ' && event < 255)
  2109.     return 1;
  2110.  
  2111.   // Cut off warning until I expand this function
  2112.   if(input!=input)
  2113.     input=input;
  2114.  
  2115.   return 0;
  2116. }
  2117.  
  2118. void add_char_inputedit(inputeditrec *input, varimenuinfo *info)
  2119. {
  2120.   if(input->insert)
  2121.   {
  2122.     if(input->curlen<input->maxlen)
  2123.     {
  2124.       memmove(input->text+input->pos+1, input->text+input->pos, input->curlen-input->pos+1);
  2125.       input->text[input->pos]=(char)info->event;
  2126.       ++input->pos;
  2127.       ++input->curlen;
  2128.     }
  2129.   }
  2130.   else
  2131.   {
  2132.     if(input->pos<input->maxlen)
  2133.     {
  2134.       input->text[input->pos]=(char)info->event;
  2135.  
  2136.       if(input->pos==input->curlen)
  2137.         ++input->curlen;
  2138.  
  2139.       ++input->pos;
  2140.     }
  2141.   }
  2142. }
  2143.  
  2144.  
  2145. void redrawinputedit(int type, inputeditrec *input, varimenuinfo *info, int mode)
  2146. {
  2147.   int savecolor=curatr;
  2148.  
  2149.   if(input->pos < input->first)
  2150.   {
  2151.     input->first=input->pos - (input->amount_to_show/2);
  2152.     if(input->first<0)
  2153.       input->first=0;
  2154.  
  2155.     type=COMMON_FULL;
  2156.   }
  2157.   else if(input->pos - input->first > input->amount_to_show)
  2158.   {
  2159.     input->first=input->pos - (input->amount_to_show/2);
  2160.     if(input->first > input->maxlen)
  2161.       input->first=input->maxlen;
  2162.     type=COMMON_FULL;
  2163.   }
  2164.   else if(input->curmode!=mode)
  2165.     type=COMMON_FULL;
  2166.  
  2167.   input->curmode=mode;
  2168.   
  2169.   input->curxpos=input->xpos+(input->pos-input->first);
  2170.   input->curypos=input->ypos;
  2171.  
  2172.   if(type==COMMON_FULL)
  2173.   {
  2174.     strncpy(input->show, input->text+input->first, input->amount_to_show);
  2175.     input->show[input->amount_to_show]=0;
  2176.  
  2177.     pad_string(input->show, input->amount_to_show);
  2178.  
  2179.     GOTO_XY(input->xpos, input->ypos);
  2180.  
  2181.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2182.  
  2183.     outstr(input->show);
  2184.   }
  2185.   else if(type==COMMON_PARTIAL)
  2186.   {
  2187.     int where = input->first+(input->pos-input->first);
  2188.     int a=input->amount_to_show-(input->pos-input->first)+1;
  2189.  
  2190.     if(input->pos!=input->first)
  2191.     {
  2192.       strncpy(input->show, input->text+where-1, a+1);
  2193.       input->show[a]=0;
  2194.       input->show[input->amount_to_show]=0 ;
  2195.  
  2196.       if(input->bs && strlen(input->show) != input->amount_to_show)
  2197.         strcat(input->show, " ");
  2198.  
  2199.       GOTO_XY(input->xpos + input->pos - input->first - 1, input->ypos);
  2200.     }
  2201.     else
  2202.     {
  2203.       strncpy(input->show, input->text+where, a);
  2204.       input->show[a]=0;
  2205.       input->show[input->amount_to_show]=0;
  2206.  
  2207.       if(input->bs && strlen(input->show) != input->amount_to_show)
  2208.         strcat(input->show, " ");
  2209.  
  2210.       GOTO_XY(input->xpos + input->pos - input->first, input->ypos);
  2211.     }
  2212.     setc(mode==COMMON_INACTIVE ? info->inactive_color : mode ==COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2213.  
  2214.     outstr(input->show);
  2215.   }
  2216.   else if(type==COMMON_NONE)
  2217.   {
  2218.   }
  2219.   else
  2220.   {
  2221.     sysoplog("Undefined update type in function redrawinputedit");
  2222.   }
  2223.  
  2224.  
  2225.   if(mode==COMMON_CURRENT)
  2226.   {
  2227.  
  2228.     info->xpos=input->xpos + input->pos - input->first;
  2229.     info->ypos=input->ypos;
  2230.     GOTO_XY(info->xpos, info->ypos);
  2231.   }
  2232.  
  2233.   input->bs=FALSE;
  2234.   setc(savecolor);
  2235. }
  2236.  
  2237.  
  2238. void delete_inputedit(inputeditrec *input, varimenuinfo *info)
  2239. {
  2240.   if((input->pos>0 && input->pos==input->curlen) || !input->curlen)
  2241.   {
  2242.     info->redraw=COMMON_NONE;
  2243.     return;
  2244.   }
  2245.  
  2246.   memmove(input->text+input->pos, input->text+input->pos+1, input->curlen-input->pos);
  2247.  
  2248.   --input->curlen;
  2249.   input->bs=TRUE;
  2250.   info->redraw=COMMON_PARTIAL;
  2251. }
  2252.  
  2253.  
  2254. void redrawradiobutton(int redraw, radiobuttonrec *radio, varimenuinfo *info, int mode)
  2255. {
  2256.   int savecolor=curatr;
  2257.   int color;
  2258.   int x=0;
  2259.  
  2260.   if(redraw==COMMON_FULL)
  2261.   {
  2262.  
  2263.     while(x<radio->amount)
  2264.     {
  2265.       color = (mode == COMMON_INACTIVE ? info->inactive_color : x == radio->pos ? info->mi_normal : info->ci_normal);
  2266.       setc(color);
  2267.  
  2268.       GOTO_XY(radio->xpos, radio->ypos+x);
  2269.       if(x==radio->pos)
  2270.         outchr(radio->radio_char);
  2271.       else
  2272.         outchr(radio->fill_char);
  2273.  
  2274.       ++x;
  2275.     }
  2276.   }
  2277.   else if(redraw!=COMMON_NONE)
  2278.   {
  2279.     if(radio->pos!=radio->last)
  2280.     {
  2281.       while(x<radio->amount)
  2282.       {
  2283.         if(x==radio->pos || x==radio->last)
  2284.         {
  2285.           color = (mode == COMMON_INACTIVE ? info->inactive_color : x == radio->pos ? info->mi_normal : info->ci_normal);
  2286.           setc(color);
  2287.  
  2288.           GOTO_XY(radio->xpos, radio->ypos+x);
  2289.           if(x==radio->pos)
  2290.             outchr(radio->radio_char);
  2291.           else
  2292.             outchr(radio->fill_char);
  2293.         }
  2294.         ++x;
  2295.       }
  2296.     }
  2297.   }
  2298.  
  2299.  
  2300.   if(mode==COMMON_CURRENT)
  2301.   {
  2302.     info->xpos=radio->xpos;
  2303.     info->ypos=radio->ypos+radio->pos;
  2304.     GOTO_XY(info->xpos, info->ypos);
  2305.   }
  2306.  
  2307.   setc(savecolor);
  2308. }
  2309.  
  2310. void redrawcheckbox(int redraw, checkboxrec *check, varimenuinfo *info, int mode)
  2311. {
  2312.   int savecolor=curatr;
  2313.   int color;
  2314.   int x=0;
  2315.  
  2316.   if(redraw==COMMON_FULL)
  2317.   {
  2318.  
  2319.     while(x<check->amount)
  2320.     {
  2321.       color = (mode == COMMON_INACTIVE ? info->inactive_color : x == check->pos ? info->mi_normal : info->ci_normal);
  2322.       setc(color);
  2323.  
  2324.       GOTO_XY(check->xpos, check->ypos+x);
  2325.       if(BitTst(check->bi.n.ni, x))
  2326.         outchr(check->check_char);
  2327.       else
  2328.         outchr(check->fill_char);
  2329.  
  2330.       ++x;
  2331.     }
  2332.   }
  2333.   else if(redraw!=COMMON_NONE)
  2334.   {
  2335.     while(x<check->amount)
  2336.     {
  2337.       if(x==check->pos)
  2338.       {
  2339.         color = (mode == COMMON_INACTIVE ? info->inactive_color : x == check->pos ? info->mi_normal : info->ci_normal);
  2340.         setc(color);
  2341.  
  2342.         GOTO_XY(check->xpos, check->ypos+x);
  2343.         if(BitTst(check->bi.n.ni, x))
  2344.           outchr(check->check_char);
  2345.         else
  2346.           outchr(check->fill_char);
  2347.       }
  2348.       ++x;
  2349.     }
  2350.   }
  2351.  
  2352.  
  2353.   if(mode==COMMON_CURRENT)
  2354.   {
  2355.     info->xpos=check->xpos;
  2356.     info->ypos=check->ypos+check->pos;
  2357.     GOTO_XY(info->xpos, info->ypos);
  2358.   }
  2359.  
  2360.   setc(savecolor);
  2361. }
  2362.  
  2363.  
  2364.  
  2365. void redrawshowtext(int redraw, showtextrec *text, varimenuinfo *info, int mode)
  2366. {
  2367.   int savecolor=curatr;
  2368.   int color;
  2369.  
  2370.   strncpy(text->show, text->text, text->amount_to_show);
  2371.   text->show[text->amount_to_show]=0;
  2372.  
  2373.   justify_string(text->show, text->amount_to_show, text->bg, text->justify);
  2374.  
  2375.   color = (mode == COMMON_INACTIVE ? info->inactive_color : mode == COMMON_ITEM ? info->mi_normal : info->ci_normal);
  2376.   if(color!=text->cur_color)
  2377.     redraw=COMMON_FULL;
  2378.   text->cur_color=color;
  2379.  
  2380.   if(redraw!=COMMON_NONE)
  2381.   {
  2382.     setc(color);
  2383.  
  2384.     GOTO_XY(text->xpos, text->ypos);
  2385.     outstr(text->show);
  2386.   }
  2387.  
  2388.   if(mode==COMMON_CURRENT)
  2389.   {
  2390.     info->xpos=text->xpos;
  2391.     info->ypos=text->ypos;
  2392.     GOTO_XY(info->xpos, info->ypos);
  2393.   }
  2394.  
  2395.   setc(savecolor);
  2396. }
  2397.  
  2398. void showtext(showtextrec *text, varimenuinfo *info)
  2399. {
  2400.  
  2401.   if(info->redraw!=COMMON_NONE)
  2402.     redrawshowtext(info->redraw, text, info, COMMON_CURRENT);
  2403.  
  2404.   info->event=get_kb_event();
  2405.   return;
  2406. }
  2407.  
  2408. void build_showtextrec(showtextrec *text, int xpos, int ypos, int width, char *t, int justify, int bg)
  2409. {
  2410.   memset(text, 0, sizeof(showtextrec));
  2411.  
  2412.   text->xpos=xpos;
  2413.   text->ypos=ypos;
  2414.   text->amount_to_show=width;
  2415.   text->curxpos=xpos;
  2416.   text->curypos=ypos;
  2417.  
  2418.   text->justify=justify;
  2419.   text->bg=bg;
  2420.  
  2421.   text->text=(char *)malloc(width+1);
  2422.   strncpy(text->text, t, width);
  2423.   text->text[width]=0;
  2424.  
  2425.   text->show=(char *)malloc(width+1);
  2426. }
  2427.  
  2428.  
  2429.  
  2430.  
  2431. // #ifdef TEST_VM
  2432. void test_vm(void)
  2433. {
  2434.   inputeditrec input1, input2;
  2435.   showtextrec text1, text2;
  2436.  
  2437.   varimenurec *menu=NULL, newmenu;
  2438.   varimenuinfo info={YELLOW+(BLUE<<4), RED+(BLUE<<4), BLACK+(CYAN<<4), RED+(CYAN<<4), DARKGRAY+(BLUE<<4),
  2439.                      COMMON_FULL, 0, 0, 0, 0, 0};
  2440.   int done=0;
  2441.  
  2442.   enum TEST_STUFF
  2443.   {
  2444.     LOGON,
  2445.     CHAT,
  2446.     EMAIL,
  2447.     GOODBYE
  2448.   };
  2449.  
  2450.  
  2451.   build_showtextrec(&text1, 5, 5, 17, "Logon", JUSTIFY_CENTER, '■');
  2452.   fillvarimenurec(&newmenu, &text1, SHOW_TEXT_TYPE, 0, LOGON, COMMON_ACTIVE);
  2453.   menu=addvarimenu(menu, &newmenu);
  2454.  
  2455.   build_showtextrec(&text2, 5, 7, 17, "GoodBye", JUSTIFY_CENTER, '∙');
  2456.   fillvarimenurec(&newmenu, &text2, SHOW_TEXT_TYPE, 0, GOODBYE, COMMON_ACTIVE);
  2457.   menu=addvarimenu(menu, &newmenu);
  2458.  
  2459.   build_inputrec(&input1, 30, 5, 9, 17, 1, IE_MIXED);
  2460.   fillvarimenurec(&newmenu, &input1, INPUT_EDIT_TYPE, 0, CHAT, COMMON_ACTIVE);
  2461.   menu=addvarimenu(menu, &newmenu);
  2462.  
  2463.  
  2464.   build_inputrec(&input2, 30, 5, 11, 17, 1, IE_PROPPER);
  2465.   fillvarimenurec(&newmenu, &input2, INPUT_EDIT_TYPE, 0, EMAIL, COMMON_ACTIVE);
  2466.   menu=addvarimenu(menu, &newmenu);
  2467.  
  2468.  
  2469.   // Print out ansi or prep screen in other way
  2470.   CLS();
  2471.  
  2472.   while(!done && !hangup)
  2473.   {
  2474.     varimenu(menu, &info);
  2475.  
  2476.     switch(info.event)
  2477.     {
  2478.       case EXECUTE:
  2479.         switch(info.returnvalue)
  2480.         {
  2481.           case GOODBYE:
  2482.           case GET_OUT:
  2483.             done=1;
  2484.             break;
  2485.           default:
  2486.             info.redraw=COMMON_NONE;
  2487.             break;
  2488.         }
  2489.         break;
  2490.  
  2491.       case GET_OUT:
  2492.         done=1;
  2493.         break;
  2494.  
  2495.       default:
  2496.         info.redraw=COMMON_NONE;
  2497.         break;
  2498.     }
  2499.  
  2500.   }
  2501.  
  2502.   killvarimenu(menu);
  2503.   CLS();
  2504. }
  2505. // #endif   // end ifdef test_var
  2506.  
  2507.  
  2508.  
  2509.  
  2510. // Waits amount of secs, or until a key is hit
  2511. void wait_sec_or_hit(double seconds)
  2512. {
  2513.   time_t time1;
  2514.   time_t time2;
  2515.  
  2516.   time(&time1);
  2517.   time(&time2);
  2518.  
  2519.   if( seconds == 1 )
  2520.     ++seconds;
  2521.  
  2522.   while(difftime(time2,time1) < seconds && !hangup && !comhit() && !kbhit())
  2523.     time(&time2);
  2524. }
  2525.  
  2526. // Waits for 'seconds' seconds, does not exit on comhit
  2527. void wait_sec(double seconds)
  2528. {
  2529.   time_t time1;
  2530.   time_t time2;
  2531.  
  2532.   time(&time1);
  2533.   time(&time2);
  2534.  
  2535.   if( seconds == 1 )
  2536.     ++seconds;
  2537.  
  2538.   while(difftime(time2,time1) < seconds && !hangup)
  2539.     time(&time2);
  2540. }
  2541.  
  2542. long filesize(FILE *stream)
  2543. {
  2544.   long curpos, length;
  2545.   
  2546.   curpos=ftell(stream);
  2547.   
  2548.   fseek(stream, 0L, SEEK_END);
  2549.   length=ftell(stream);
  2550.   
  2551.   fseek(stream, curpos, SEEK_SET);
  2552.   
  2553.   return length;
  2554. }
  2555.  
  2556.  
  2557.  
  2558. int fset_rec(FILE *stream, unsigned rec, unsigned rec_size)
  2559. {
  2560.   int error;
  2561.   
  2562.   error = fseek(stream, (long) ((rec)*((long)rec_size)), SEEK_SET);
  2563.  
  2564.   
  2565.   if(error)
  2566.     ; // Could not set rec
  2567.     
  2568.   return(!error);
  2569. }
  2570.  
  2571. int set_rec(int filenum, unsigned rec, unsigned rec_size)
  2572. {
  2573.   int error;
  2574.   
  2575.   error = sh_lseek(filenum, (long) ((rec)*((long)rec_size)), SEEK_SET);
  2576.  
  2577.   
  2578.   if(error)
  2579.     ; // Could not set rec
  2580.     
  2581.   return(!error);
  2582. }
  2583.  
  2584.  
  2585.  
  2586. // #define check_ar(which) check_bitfield(thisuser.ar, (which))
  2587. // #define check_dar(which) check_bitfield(thisuser.dar, (which))
  2588. // These are defined in COMMON.H, example calls:
  2589. //
  2590. // if(check_ar("CDF"))  (or if(check_dar("GA"))
  2591. //   do_whatever();
  2592. //
  2593. // It will return TRUE (1) if all bits specified in paremater 'which' are set
  2594. // Say in check_ar("CDF"), if the user has CD, but not F specified, then FALSE
  2595. // (0) is returned/
  2596. //
  2597. // To use check_bitfield, you must specify the bitfield you are checking, and
  2598. // you must specify bit 'A' as the first bit, 'B' as the second... on up to 'P'
  2599. // as your 16th bit, and paremater 'which' is used just as above
  2600. //
  2601. // if(check_bitfield(thisuser.restrict, "AC"))
  2602. //   annoy_user_a_little();
  2603. //
  2604. // Should make checking bit fields for novice users, as well as everyone else
  2605. // alot easier
  2606.  
  2607. int check_bitfield(unsigned bitfield, char *which)
  2608. {
  2609.   unsigned total=0, bit, temp;
  2610.   int x=0, y;
  2611.  
  2612.   strupr(which);
  2613.  
  2614.   while((y=which[x])!=0)
  2615.   {
  2616.     // There IS error detection for if you specify the same bit field
  2617.     // twice, or if you specify something other than A-P
  2618.     if(y>='A' && y <= 'P')
  2619.     {
  2620.       bit=1 << (y-'A');
  2621.       // Make sure that this bit has not already been set
  2622.       if(!(total&bit))
  2623.         total+=bit;
  2624.     }
  2625.     ++x;
  2626.   }
  2627.  
  2628.   temp=bitfield & total;
  2629.   if(temp==total)
  2630.     return 1;
  2631.   return 0;
  2632. }
  2633.  
  2634.  
  2635. #ifdef TEST_BITFIELD
  2636. void test_check_bitfield(void)
  2637. {
  2638.   int done=0;
  2639.   char s[17];
  2640.  
  2641.   while(!done)
  2642.   {
  2643.     pl("Enter alpha style bit field to check against thisuser.ar");
  2644.     input(s, 16);
  2645.  
  2646.     if(s[0])
  2647.     {
  2648.       if(check_ar(s))
  2649.         pl("You have the specified bits");
  2650.       else
  2651.         pl("You DON'T have the specified bits");
  2652.     }
  2653.     else
  2654.       done=1;
  2655.   }
  2656. }
  2657. #endif
  2658.  
  2659.  
  2660. int check_arc(char *filename)
  2661. {
  2662.   char header[10];
  2663.   char *ext;
  2664.   int file;
  2665.  
  2666.  
  2667.   file=sh_open1(filename, O_RDONLY);
  2668.  
  2669.   if(file<0)
  2670.     return(COMPRESSION_UNKNOWN);
  2671.  
  2672.   sh_lseek(file, 0, SEEK_SET);
  2673.   sh_read(file, (void *)&header, 10);
  2674.  
  2675.   sh_close(file);
  2676.  
  2677.   switch(header[0])
  2678.   {
  2679.     case 0x60:
  2680.       if((unsigned char)header[2]==(unsigned char)0xEA)
  2681.         return(COMPRESSION_ARJ);
  2682.  
  2683.       break;
  2684.  
  2685.     case 0x1a:
  2686.       return(COMPRESSION_PAK);
  2687.  
  2688.     case 'P':
  2689.       if(header[1]=='K')
  2690.         return(COMPRESSION_ZIP);
  2691.  
  2692.       break;
  2693.  
  2694.     case 'Z':
  2695.       if(header[1]== 'O' && header[2] == 'O')
  2696.         return(COMPRESSION_ZOO);
  2697.  
  2698.       break;
  2699.  
  2700.     default:
  2701.  
  2702.       if(strstr(header, "-lh"))
  2703.         return(COMPRESSION_LHA);
  2704.  
  2705.       // Guess on type, using extension to guess
  2706.       ext=strstr(filename, ".");
  2707.  
  2708.       if(ext)
  2709.       {
  2710.         ++ext;
  2711.  
  2712.         if(stricmp(ext, "ZIP")==0)
  2713.           return(COMPRESSION_ZIP);
  2714.  
  2715.         if(stricmp(ext, "LHA")==0)
  2716.           return(COMPRESSION_LHA);
  2717.  
  2718.         if(stricmp(ext, "LZH")==0)
  2719.           return(COMPRESSION_LHA);
  2720.  
  2721.         if(stricmp(ext, "ZOO")==0)
  2722.           return(COMPRESSION_ZOO);
  2723.  
  2724.         if(stricmp(ext, "ARC")==0)
  2725.           return(COMPRESSION_PAK);
  2726.  
  2727.         if(stricmp(ext, "PAK")==0)
  2728.           return(COMPRESSION_PAK);
  2729.  
  2730.         if(stricmp(ext, "ARJ")==0)
  2731.           return(COMPRESSION_ARJ);
  2732.  
  2733.         return(COMPRESSION_UNKNOWN);
  2734.       }
  2735.   }
  2736.   return(COMPRESSION_UNKNOWN);
  2737. }
  2738.  
  2739. // Returns which archive as a number in your archive config
  2740. // Returns the first archiver you have listed if unknown
  2741. // One thing to note, if an 'arc' is found, it uses pak, and returns that
  2742. // The reason being, PAK does all ARC does, plus a little more, I belive
  2743. // PAK has its own special modes, but still look like an ARC, thus, an ARC
  2744. // Will puke if it sees this
  2745. int match_archiver(char *filename)
  2746. {
  2747.   int x=0;
  2748.   char type[4];
  2749.  
  2750.   x=check_arc(filename);
  2751.  
  2752.   if(x==COMPRESSION_UNKNOWN)
  2753.     return 0;
  2754.  
  2755.  
  2756.   switch(x)
  2757.   {
  2758.     case COMPRESSION_ZIP:
  2759.       strcpy(type, "ZIP");
  2760.       break;
  2761.  
  2762.     case COMPRESSION_LHA:
  2763.       strcpy(type, "LHA");
  2764.       break;
  2765.  
  2766.     case COMPRESSION_ARJ:
  2767.       strcpy(type, "ARJ");
  2768.       break;
  2769.  
  2770.     case COMPRESSION_PAK:
  2771.       strcpy(type, "PAK");
  2772.       break;
  2773.  
  2774.     case COMPRESSION_ZOO:
  2775.       strcpy(type, "ZOO");
  2776.       break;
  2777.   }
  2778.  
  2779.   x=0;
  2780.  
  2781.   while(x<4)
  2782.   {
  2783.     if(stricmp(type, syscfg.arcs[x].extension)==0)
  2784.       return x;
  2785.  
  2786.     ++x;
  2787.   }
  2788.  
  2789.   return 0;
  2790. }
  2791.  
  2792.  
  2793. void strip_heart_colors(char *text)
  2794. {
  2795.   int pos=0;
  2796.   int len=strlen(text);
  2797.  
  2798.   while(pos<len && text[pos] != 26 && !hangup)
  2799.   {
  2800.     if(text[pos]==3)
  2801.     {
  2802.       memmove(text+pos, text+pos+2, len-pos);
  2803.       --len;
  2804.       --len;
  2805.     }
  2806.     else
  2807.       ++pos;
  2808.   }
  2809. }
  2810.  
  2811. long file_daten(char *filename)
  2812. {
  2813.   int fn;
  2814.  
  2815.   struct ftime file;
  2816.   struct time  dtime;
  2817.   struct date  ddate;
  2818.  
  2819.  
  2820.   fn = sh_open1(filename, O_RDONLY);
  2821.   if (fn != -1)
  2822.   {
  2823.     getftime(fn, &file);
  2824.     fn=sh_close(fn);
  2825.  
  2826.     dtime.ti_hund = 0;
  2827.     dtime.ti_min = file.ft_min;
  2828.     dtime.ti_hour = file.ft_hour;
  2829.     dtime.ti_sec = file.ft_tsec * 2;
  2830.     ddate.da_year = file.ft_year + 1980;
  2831.     ddate.da_day = file.ft_day;
  2832.     ddate.da_mon = file.ft_month;
  2833.  
  2834.     return(dostounix(&ddate, &dtime));
  2835.   }
  2836.   return 0;
  2837. }
  2838.  
  2839.  
  2840.  
  2841.  
  2842.  
  2843.